#include <vector>
#include <set>
#include <queue>
#include <list>
#include <iostream>

using namespace std;

typedef list< short>   lshort;
typedef vector< short>   vshort;
typedef vector< int>   vint;
typedef vector< bool>   vbool;
typedef set< short>   sshort; 
typedef vector< vshort>   vvshort;
typedef vector< set<short> >   vsshort;

#define contains(SET,ELEM) SET.find(ELEM) != SET.end()
#define INFINITY 100000
#define ERROR -1

class Grafo{
public:
	Grafo(short n);
	void agregarEje(short i, short j, short costo);
	void eliminarEje(short i, short j);
	lshort shortestPathBellmanFord();
	lshort shortestPathDijkstra();
	int edgeDisjointShortestPairPathsCost();
private:
	vvshort costos;
	vsshort adyacentes;
	short cantidadNodos;
};

Grafo::Grafo(short n){
	cantidadNodos = n;
	costos = vvshort(n+1 , vshort(n+1,0));
	adyacentes = vsshort(n+1,sshort());
}
//Agrega un eje y su inverso con el costo asociado
void Grafo::agregarEje(short i, short j, short costo){
	costos[i][j] = costo;
	costos[j][i] = costo;
	adyacentes[i].insert(j);
	adyacentes[j].insert(i);
}

void Grafo::eliminarEje(short i, short j){
	adyacentes[i].erase(j);
}

// Obtiene un camino minimo desde el nodo 1 al nodo n y lo retorna como una lista de nodos
// Algoritmo Bellman-Ford: para utilizar cuando el grafo tiene ejes negativos
lshort Grafo::shortestPathBellmanFord(){
	lshort res;
	vint d(cantidadNodos+1, INFINITY); 	//distancias al nodo 1
	vshort p(cantidadNodos+1, 0); 		// padre
	vbool en_cola(cantidadNodos+1, false);	//nodos que faltan analizar
	queue<short> q;
	d[1] = 0;
	q.push(1);
	en_cola[1] = true;
	while(!q.empty()){
		short u = q.front();
		q.pop();
		en_cola[u] = false;
		for (set<short>::iterator it=adyacentes[u].begin() ; it != adyacentes[u].end(); ++it ){
			short v = *it;
			if (d[v] > d[u] + costos[u][v]){
				d[v] = d[u] + costos[u][v];
				p[v] = u;
				if (! en_cola[v]){
					q.push(v);
					en_cola[v] = true;
				}
			}
		}
	}
	// si no hay camino retorno la lista vacia
	if (d[cantidadNodos] == INFINITY) return lshort();
	//rearmo el camino minimo
	short c = cantidadNodos;
	res.push_front(c);
	while (c != 1){
		c = p[c];
		res.push_front(c);
	}
	return res;
}
// Obtiene un camino minimo desde el nodo 1 al nodo n y lo retorna como una lista de nodos
// Algoritmo Dijkstra: para utilizar cuando el grafo no tiene ejes negativos
lshort Grafo::shortestPathDijkstra(){
	lshort res;
	vint d(cantidadNodos+1, INFINITY); 	//distancias al nodo 1
	vshort p(cantidadNodos+1, 0); 		// padre
	vbool visitados(cantidadNodos+1, false); //nodos que ya fueron analizados
	short restanVisitar = cantidadNodos;	// cantidad de nodos que restan visitar
	d[1] = 0;
	while (restanVisitar > 0){
		// obtengo el nodo con distancia minima de los no visitados
		short min = 0;
		int minDist = INFINITY;
		for (short i = 1; i < cantidadNodos+1; ++i){
			if (d[i] < minDist && !visitados[i]){
				min = i;
				minDist = d[i];
			}
		}
		if (d[min] == INFINITY) break; // los nodos restantes son inalcanzables
		if (min == cantidadNodos) break; //llegue al nodo final
		visitados[min] = true;
		
		// Para todos los adyacentes que no fueron visitados
		for (set<short>::iterator it=adyacentes[min].begin() ; it != adyacentes[min].end(); ++it ){
			short v = *it;
			if (!visitados[v]){
				//me fijo si puedo mejorar la distancia
				int alt = d[min] + costos[min][v];
				if (alt < d[v]){
					d[v] = alt;
					p[v] = min;
				}
			}
		}
		
		restanVisitar--;
	}
	
	// si no hay camino al nodo final => retorno la lista vacia
	if (d[cantidadNodos] == INFINITY) return lshort();
	//rearmo el camino minimo
	short c = cantidadNodos;
	res.push_front(c);
	while (c != 1){
		c = p[c];
		res.push_front(c);
	}
	
	return res;
}
 
int Grafo::edgeDisjointShortestPairPathsCost(){
	int costo1 = 0, costo2 = 0;
	// PASO 1: obtengo un camino minimo
	lshort camino1 = shortestPathDijkstra();
	if (camino1.empty()) return ERROR;
	// PASO 2: elimino los ejes del camino e invierto los costos de los ejes inversos
	list<short>::iterator it = camino1.begin();
	short ant = *it;
	it++;
	while (it != camino1.end()){
		short sig = *it;
		eliminarEje(ant,sig);			// saturo el nodo
		costos[sig][ant] *= -1;			// invierto el costo del eje opuesto
		costo1 += costos[ant][sig];		// se agrego el eje al flujo => sumo su costo
		ant = sig;
		it++;
	}
	// PASO 3: obtengo un nuevo camino mínimo (puede haber ejes negativos)
	lshort camino2 = shortestPathBellmanFord();
	if (camino2.empty()) return ERROR;			
	// PASO 4: sumo los costos de los ejes que no estaban en el camino anterior (invertidos)
	it = camino2.begin();
	ant = *it;
	it++;
	while (it != camino2.end()){
		short sig = *it;
		costo2 += costos[ant][sig]; // notar que si el eje ya habia sido usado en el camino1 => se resta el costo
		ant = sig;
		it++;
	}

	return costo1 + costo2;
}


int main(int argc, char *argv[]) {
	
    short n;
    scanf ("%hd",&n);

    while ( n != 0 ) {
		Grafo g(n);
		short m;
		short u, v;
		short w;
		scanf ("%hd",&m);
		for( short i = 0; i < m; ++i ){
			scanf ("%hd",&u);
			scanf ("%hd",&v);
			scanf ("%hd",&w);
			g.agregarEje(u,v,w);
		}
		int costo = g.edgeDisjointShortestPairPathsCost();
		if (costo == ERROR){
			printf("Back to jail\n");
		} else {
			printf("%d\n", costo);
		}
		scanf ("%hd",&n);
	}
}
